Técnicas de Refatoração em Python: Um Guia Abrangente para a Melhoria da Qualidade do Código

No cenário em constante evolução do desenvolvimento de software, manter um código limpo, eficiente e compreensível é primordial. O Python, conhecido pela sua legibilidade, ainda pode ser vítima de "code smells" e débito técnico se não for gerido cuidadosamente. Refatoração é o processo de reestruturar o código de computador existente — alterando a fatoração — sem modificar o seu comportamento externo. Em essência, é limpar o seu código sem o quebrar. Este guia explora várias técnicas de refatoração em Python, fornecendo exemplos práticos e as melhores práticas para elevar a qualidade do seu código.

Por Que Refatorar Código Python?

A refatoração oferece inúmeros benefícios, incluindo:

• Legibilidade Aprimorada: Torna o código mais fácil de entender e manter.
• Complexidade Reduzida: Simplifica lógicas complexas, reduzindo a probabilidade de erros.
• Manutenibilidade Melhorada: Facilita a modificação e extensão do código.
• Desempenho Aumentado: Pode otimizar o código para uma melhor velocidade de execução.
• Débito Técnico Menor: Evita a acumulação de código que é difícil de manter ou estender.
• Melhor Design: Leva a uma arquitetura de código mais robusta e flexível.

Ignorar a refatoração pode levar a um código difícil de entender, modificar e testar. Isso pode aumentar significativamente o tempo de desenvolvimento e o risco de introduzir bugs.

Quando Refatorar?

Saber quando refatorar é crucial. Aqui estão alguns cenários comuns:

• Antes de Adicionar Novos Recursos: Refatorar o código existente pode facilitar a integração de novas funcionalidades.
• Após Corrigir um Bug: Refatorar o código ao redor pode evitar que bugs semelhantes voltem a ocorrer.
• Durante as Revisões de Código: Identifique áreas que podem ser melhoradas e refatore-as.
• Quando Encontrar "Code Smells": "Code smells" são indicadores de problemas potenciais no seu código.
• Refatoração Programada Regularmente: Incorpore a refatoração no seu processo de desenvolvimento como uma atividade regular.

Identificando "Code Smells"

"Code smells" são indicações superficiais que geralmente correspondem a um problema mais profundo no sistema. Eles nem sempre indicam um problema, mas frequentemente justificam uma investigação mais aprofundada.

"Code Smells" Comuns em Python:

• Código Duplicado: Código idêntico ou muito semelhante que aparece em vários lugares.
• Método/Função Longo: Métodos ou funções que são excessivamente longos e complexos.
• Classe Grande: Classes que têm demasiadas responsabilidades.
• Lista de Parâmetros Longa: Métodos ou funções com demasiados parâmetros.
• Aglomerados de Dados: Grupos de dados que frequentemente aparecem juntos.
• Obsessão Primitiva: Usar tipos de dados primitivos em vez de criar objetos.
• Instruções Switch: Longas cadeias de instruções if/elif/else ou instruções switch.
• Cirurgia de Espingarda (Shotgun Surgery): Fazer uma única alteração requer fazer muitas pequenas alterações em diferentes classes.
• Alteração Divergente: Uma classe é comumente alterada de diferentes maneiras por diferentes razões.
• Inveja de Funcionalidade (Feature Envy): Um método acede mais aos dados de outro objeto do que aos seus próprios dados.
• Cadeias de Mensagens: Um cliente pede a um objeto para solicitar a outro objeto que solicite a ainda outro objeto...

Técnicas de Refatoração em Python: Um Guia Prático

Esta seção detalha várias técnicas comuns de refatoração em Python com exemplos práticos.

1. Extrair Método/Função

Esta técnica envolve pegar um bloco de código dentro de um método ou função e movê-lo para um novo método ou função separado. Isso reduz a complexidade do método original e torna o código extraído reutilizável.

Exemplo:

            
def print_invoice(customer, details):
    print("***********************")
    print(f"Customer: {customer}")
    print("***********************")

    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]

    print(f"Amount is : {total_amount}")

    if total_amount > 1000:
        print("You earned a discount!")

            

              
                Copy
              
            
          

Refatorado:

            
def print_header(customer):
    print("***********************")
    print(f"Customer: {customer}")
    print("***********************")


def calculate_total(details):
    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]
    return total_amount


def print_invoice(customer, details):
    print_header(customer)
    total_amount = calculate_total(details)
    print(f"Amount is : {total_amount}")

    if total_amount > 1000:
        print("You earned a discount!")

            

              
                Copy
              
            
          

2. Extrair Classe

Quando uma classe tem demasiadas responsabilidades, extraia algumas delas para uma nova classe. Isso promove o Princípio da Responsabilidade Única.

Exemplo:

            
class Person:
    def __init__(self, name, phone_number, office_area_code, office_number):
        self.name = name
        self.phone_number = phone_number
        self.office_area_code = office_area_code
        self.office_number = office_number

    def get_name(self):
        return self.name

    def get_phone_number(self):
        return f"({self.office_area_code}) {self.office_number}"

            

              
                Copy
              
            
          

Refatorado:

            
class PhoneNumber:
    def __init__(self, area_code, number):
        self.area_code = area_code
        self.number = number

    def get_phone_number(self):
        return f"({self.area_code}) {self.number}"


class Person:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number

    def get_name(self):
        return self.name


            

              
                Copy
              
            
          

3. Embutir Método/Função

Isto é o oposto de Extrair Método. Se o corpo de um método é tão claro quanto o seu nome, pode embutir o método substituindo as chamadas ao método pelo conteúdo do método.

Exemplo:

            
def get_rating(driver):
    return more_than_five_late_deliveries(driver) ? 2 : 1


def more_than_five_late_deliveries(driver):
    return driver.number_of_late_deliveries > 5

            

              
                Copy
              
            
          

Refatorado:

            
def get_rating(driver):
    return driver.number_of_late_deliveries > 5 ? 2 : 1

            

              
                Copy
              
            
          

4. Substituir Variável Temporária por Consulta

Em vez de usar uma variável temporária para guardar o resultado de uma expressão, extraia a expressão para um método. Isso evita a duplicação de código e promove uma melhor legibilidade.

Exemplo:

            
def get_price(order):
    base_price = order.quantity * order.item_price
    discount_factor = 0.98 if base_price > 1000 else 0.95
    return base_price * discount_factor

            

              
                Copy
              
            
          

Refatorado:

            
def get_price(order):
    return base_price(order) * discount_factor(order)


def base_price(order):
    return order.quantity * order.item_price


def discount_factor(order):
    return 0.98 if base_price(order) > 1000 else 0.95

            

              
                Copy
              
            
          

5. Introduzir Objeto de Parâmetro

Se tiver uma longa lista de parâmetros que aparecem frequentemente juntos, considere criar um objeto de parâmetro para os encapsular. Isso reduz o comprimento da lista de parâmetros e melhora a organização do código.

Exemplo:

            
def calculate_total(width, height, depth, weight, shipping_method):
    # Lógica de cálculo
    pass

            

              
                Copy
              
            
          

Refatorado:

            
class ShippingDetails:
    def __init__(self, width, height, depth, weight, shipping_method):
        self.width = width
        self.height = height
        self.depth = depth
        self.weight = weight
        self.shipping_method = shipping_method


def calculate_total(shipping_details):
    # Lógica de cálculo usando atributos de shipping_details
    pass

            

              
                Copy